﻿//#include<iostream>
//using namespace std;
//struct Point
//{
//	int _x;
//	int _y;
//};
//
//
//int main()
//{
//	int arr1[] = { 1,2,3,4,5 };
//	int arr2[5] = { 0 };
//	Point p = { 1,2 };
//
//	return 0;
//}


#include<iostream>
#include<vector>
#include<map>
using namespace std;
//struct Point
//{
//	int _x;
//	int _y;
//};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
// ⼀切皆可⽤列表初始化，且可以不加= 


void PushBack(const Date& d)
{
}


//class Solution {
//public:
//	// 传值返回需要拷⻉ 
//	string addStrings(string num1, string num2) {
//		string str;
//		int end1 = num1.size() - 1, end2 = num2.size() - 1;
//		// 进位 
//		int next = 0;
//		while (end1 >= 0 || end2 >= 0)
//		{
//			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
//			int ret = val1 + val2 + next;
//			next = ret / 10;
//			ret = ret % 10;
//			str += ('0' + ret);
//		}
//		if (next == 1)
//			str += '1';
//		reverse(str.begin(), str.end());
//		return str;
//
//	}
//};





////⼀个const左值引⽤作为参数的函数，那么实参传递左值和右值都可以匹配
//void f(const int& x)
//{
//	std::cout << "到 const 的左值引⽤重载 f(" << x << ")\n";
//}
//
//void f(int& x)
//{
//	std::cout << "左值引⽤重载 f(" << x << ")\n";
//}
//
//void f(int&& x)
//{
//	std::cout << "右值引⽤重载 f(" << x << ")\n";
//}
//
//int main()
//{
//	int i = 1;
//	const int ci = 2;
//	f(i); // 调⽤ f(int&) 
//	f(ci); // 调⽤ f(const int&) 
//	f(3); // 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&) 
//	f(std::move(i)); // 调⽤ f(int&&) 
//
//	// 右值引⽤变量在⽤于表达式时是左值 
//	int&& x = 1;
//	f(x); // 调⽤ f(int& x) 
//	f(std::move(x)); // 调⽤ f(int&& x) 
//
//
//	return 0;
//}



//class AA
//{
//public:
//	AA(int a,int b)
//		:_a(a)
//		, _b(b)
//	{
//	}
//	~AA()
//	{
//		cout << "~AA()" << endl;
//	}
//private:
//	int _a;
//	int _b;
//};
//int main()
//{
//	AA aa1(1, 2);
//	const AA& rr1 = AA(5, 7);
//	AA&& rr2 = AA(5, 7);
//
//	cout << "------------------------- " << endl;
//
//	return 0;
//}

//int main()
//{
//	std::string s1 = "Test";
//	// std::string&& r1 = s1; // 错误：不能绑定到左值 
//
//	const std::string& r2 = s1 + s1; // OK：到 const 的左值引⽤延⻓⽣存期
//	// r2 += "Test"; // 错误：不能通过到 const 的引⽤修改 
//
//	std::string&& r3 = s1 + s1; // OK：右值引⽤延⻓⽣存期
//	r3 += "Test"; // OK：能通过到⾮ const 的引⽤修改 
//
//	std::cout << r3 << '\n';
//	return 0;
//}

//template<class T>
//class vector {
//public:
//	typedef T* iterator;
//
//	vector(initializer_list<T> l)
//	{
//		for (auto& e : l)
//			push_back(e);
//	}
//
//private:
//	iterator _start = nullptr;
//	iterator _finish = nullptr;
//	iterator _endofstorage = nullptr;
//};

//int main()
//{
//
//
//	//double x = 1.1, y = 2.2;
//	////const左值引⽤可以引⽤右值
//	//const double& rr1 = x + y;
//
//	////左值
//	//int b = 1;
//	////右值引⽤可以引⽤move(左值)
//	//int&& rr1 = (int&&)b;
//	//int* p = new int(0);
//	//int b = 1;
//	//const int c = b;
//	//*p = 10;
//	//string s("111111");
//	//// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值) 
//	//int&& rrx1 = move(b);
//	//int*&& rrx2 = move(p);
//	//int&& rrx3 = move(*p);
//	//string&& rrx4 = move(s);
//	//string&& rrx5 = (string&&)s;
//
//
//	//// b、r1、rr1都是变量表达式，都是左值 
//	//cout << &b << endl;
//	//cout << &r1 << endl;
//	//cout << &rr1 << endl;
//
//
//	////右值引用
//	//int&& rr1 = 10;
//	//double&& rr2 = x + y;
//	//string&& rr3 = string("11111");
//
//
//	//// 右值：不能取地址 
//	//double x = 1.1, y = 2.2;
//	//// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值 
//	//10;
//	//x + y;
//	//fmin(x, y);
//	//string("11111");
//	//cout << &10 << endl;
// //   cout << &(x+y) << endl;
//	//cout << &(fmin(x, y)) << endl;
//	//cout << &string("11111") << endl;
//
//
//
//
//	//// 左值：可以取地址 
// //   // 以下的p、b、c、*p、s、s[0]就是常⻅的左值 
//	//int* p = new int(0);
//	//int b = 1;
//	//const int c = b;
//	//*p = 10;
//	//string s("111111");
//	//s[0] = 'x';
//	//cout << &c << endl;
//	//cout << (void*)&s[0] << endl;
//
//
//	//// 这里是pair对象的{}初始化和map的initializer_list构造结合到一起用了
//	//map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };
//
//	//pair<string, string> kv1("sort", "排序");
//	//pair<string, string> kv2("string", "字符串");
//	//map<string, string> dict = { kv1, kv2 };
//
//	//initializer_list<int> mylist;
//	//mylist = { 10, 20, 30 };
//	//cout << sizeof(mylist) << endl;
//	//// 这⾥begin和end返回的值initializer_list对象中存的两个指针 
// //   // 这两个指针的值跟i的地址跟接近，说明数组存在栈上 
//	//int i = 0;
//	//cout << mylist.begin() << endl;
//	//cout << mylist.end() << endl;
//	//cout << &i << endl;
//
//
//	//vector<int> v1 = { 1,2,3,4 };
//	//vector<int> v2 = { 1,2,3,4,5,6,7 };
//
//	////赋值也⽀持initializer_list的版本
//	//v1 = { 10,20,30 };
//
//	/*auto il = { 10,20,30,40,50 };
//	cout << typeid(il).name() << endl;*/
//
//	//PushBack(2025);
//	//PushBack({ 2025,1 });
//	//PushBack({2025,1,4});
//
//
//	//// 可以省略掉=
//	//Point p1{ 1, 2 };
//	//int x2{ 2 };
//	//Date d6{ 2024, 7, 25 };
//	//const Date& d7{ 2024, 7, 25 };
//
//	//// ⾃定义类型⽀持 
//	//// 这⾥本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象 
//	//// 临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化d1
//	//// 运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的 
//	//Date d1 = { 2025, 1, 1 };
//	//Date d2 = 2025;
//	//string sl = "1111111";
//
//	//const Date& d1 = 2025;
//	//const Date& d2 = { 2025, 1, 1 };
//
//	// C++11⽀持的 
//    // 内置类型⽀持 
//	//int x1 = { 2 };
//
//
//
//
//
//	return 0;
//}



